
package gliste
import java.util.logging.Logger;
import org.apache.commons.codec.digest.DigestUtils;
import src.de.checker.hochzeit.domain.util.*;
import src.de.checker.hochzeit.domain.user.*;
import src.de.checker.hochzeit.konstanten.*
import com.google.appengine.api.datastore.*
import src.de.checker.hochzeit.util.*;
import static com.google.appengine.api.datastore.FetchOptions.Builder.*

Logger log = Logger.getLogger('GaesteController');

int asc = -1;
int desc = 1;
if(session.getAttribute(Konstanten.SESSION_USER) != null)
{
	def kquery = new Query(Konstanten.KATEGORIE)
	kquery.addSort("id", Query.SortDirection.ASCENDING)
	PreparedQuery kpreparedQuery = datastore.prepare(kquery)
	def entitiesk = kpreparedQuery.asList( withLimit(100) )
	request['listkat'] = entitiesk
	
	def rquery = new Query(Konstanten.ROLLE)
	rquery.addSort("id", Query.SortDirection.DESCENDING)
	PreparedQuery rpreparedQuery = datastore.prepare(rquery)
	def entitiesr = rpreparedQuery.asList( withLimit(100) )
	request['listrole'] = entitiesr
	
	def tquery = new Query(Konstanten.TT)
	tquery.addSort("id", Query.SortDirection.ASCENDING)
	PreparedQuery tpreparedQuery = datastore.prepare(tquery)
	def entitiest = tpreparedQuery.asList( withLimit(100) )
	request['listtt'] = entitiest
	
	
	if(params?.index ==~ /(?i)true/)
	{
		index()
	}
	if(params?.show ==~ /(?i)true/)
	{
		show()
	}
	if(params?.edit ==~ /(?i)true/)
	{
		edit()
	}
	if(params?.updateuser ==~ /(?i)true/)
	{
		update()
	}
	if(params?.updatekind ==~ /(?i)true/)
	{
		updatekind()
	}
	if(params?.updateanhang ==~ /(?i)true/)
	{
		updateanhang()
	}
}

private void index()
{
	String sort = ""
	int order = getOrder()
	
	def query = new Query(Konstanten.GAST)
	query.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	
	if(params.sort)
		sort = params.sort
	
	if(!sort.equals(''))
	{
		if(order == -1)
			query.addSort(sort, Query.SortDirection.ASCENDING)
		else
			query.addSort(sort, Query.SortDirection.DESCENDING)
	}
	else
	{
		query.addSort("rolle", Query.SortDirection.ASCENDING)
		query.addSort("kategorie", Query.SortDirection.ASCENDING)
		query.addSort("nachname", Query.SortDirection.ASCENDING)
		query.addSort("strasse", Query.SortDirection.ASCENDING)
	}
	
	
    PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(300) )
	request['list'] = entities
	request['size'] = entities.size()
	request['order'] = order;
	
    HashMap kinder = new HashMap()
	HashMap anhang = new HashMap()
    
    for(i in entities)
    {
    	kinder.put(i.key.id, new ArrayList())
    	List list =  new ArrayList()
    	list.add(i)
    	anhang.put(i.key.id, list)
    }
    
    def query1 = new Query(Konstanten.KIND)
    query1.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	PreparedQuery preparedQuery1 = datastore.prepare(query1)
	def entities1 = preparedQuery1.asList( withLimit(100) )
	request['ksize'] = entities1.size()
	
	def query2 = new Query(Konstanten.ANHANG)
    query2.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	PreparedQuery preparedQuery2 = datastore.prepare(query2)
	def entities2 = preparedQuery2.asList( withLimit(100) )
	request['asize'] = entities2.size()
	
	for(i in entities1)
	{
		Long gast = i.gast
		ArrayList liste = kinder.get(gast)
		liste.add(i)
		kinder.put (gast, liste)
	}
    for(i in entities2)
	{
		Long gast = i.gast
		ArrayList liste = anhang.get(gast)
		liste.add(i)
		anhang.put (gast, liste)
	}
	request['kinder'] = kinder
	request['anhang'] = anhang
	
	forward '/gliste/uebersicht.gtpl'
}

private void show()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def entity = datastore.get(k);
		if(entity.feier.equals(feier))
		{
			request['gast'] =  entity
			
			def query = new Query(Konstanten.TELEKOMM)
			query.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			
			PreparedQuery preparedQuery = datastore.prepare(query)
		 	def entities = preparedQuery.asList( withLimit(100) )
			
		 	request['email'] = ''
			request['handy'] = ''
			request['telefon'] = ''
			for (i in entities)
			{
				if(i.typ == 0)
				{
					request['email'] = i.wert
				}
				if(i.typ == 1)
				{
					request['handy'] = i.wert
				}
				if(i.typ == 2)
				{
					request['telefon'] = i.wert
				}
			}
			
			
			def query1 = new Query(Konstanten.ANHANG)
			query1.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery1 = datastore.prepare(query1)
		 	def entities1 = preparedQuery1.asList( withLimit(100) )
			request['anhang'] = entities1
			
			def query2 = new Query(Konstanten.KIND)
			query2.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery2 = datastore.prepare(query2)
		 	def entities2 = preparedQuery2.asList( withLimit(100) )
			request['kind'] = entities2
			
			//log.info("Anzahl der Kinder: "+entities2.size);
			forward '/gliste/show.gtpl'
		}
		else
		{
			String message = "Es wurde versucht ein Gast anzuzeigen (Planer), der nicht zur eigenen Feier gehört: "+entity.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gliste.gaeste.show(): Benutzer: "+session.getAttribute(Konstanten.SESSION_USER)+" hat versucht eine Entity anzufordern, die nicht zur Hochzeitsfeier gehört: "+entity)
			index()
		}
	}
	//Hier kommt man hin, wenn man am request-parameter params.key selber rumpfuscht
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast anzuschaun(gliste), den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gliste.gaeste.show(): VERBOTEN: Es wurde versucht ein Gast anzuschaun, den es nicht gibt. Benutzer der gesucht hat: "+myuser+" Params: "+params)
		index()
	}	
}
private void edit()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def entity = datastore.get(k);
		if(entity.feier.equals(feier))
		{
			request['gast'] =  entity
			
			def query = new Query(Konstanten.TELEKOMM)
			query.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery = datastore.prepare(query)
		 	def entities = preparedQuery.asList( withLimit(100) )
			//request['tele'] = entities
		 	request['email'] = ''
			request['handy'] = ''
			request['telefon'] = ''
			for (i in entities)
			{
				if(i.typ == 0)
				{
					request['email'] = i.wert
				}
				if(i.typ == 1)
				{
					request['handy'] = i.wert
				}
				if(i.typ == 2)
				{
					request['telefon'] = i.wert
				}
			}
			
			
			def query1 = new Query(Konstanten.ANHANG)
			query1.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery1 = datastore.prepare(query1)
		 	def entities1 = preparedQuery1.asList( withLimit(100) )
			request['anhang'] = entities1
			
			def query2 = new Query(Konstanten.KIND)
			query2.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery2 = datastore.prepare(query2)
		 	def entities2 = preparedQuery2.asList( withLimit(100) )
			request['kind'] = entities2
			
			//log.info("Anzahl der Kinder: "+entities2.size);
			
			forward '/gliste/edit.gtpl'
		}
		else
		{
			String message = "Es wurde versucht ein Gast zu editieren, der nicht zur eigenen Feier gehört: "+entity.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.edit(): Gast gehört nicht zur eigenen Feier:"+entity+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
			index()
		}
	}
	//Hier kommt man hin, wenn man am request-parameter params.key selber rumpfuscht
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast zu editieren, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gliste.edit(): VERBOTEN: Es wurde versucht ein Gast zu editieren, den es nicht gibt. Benutzer der gesucht hat: "+myuser+" Params: "+params)
		index()
	}	
}
private boolean hasUserChanged(def params, Entity nutzer)
{
	if(!nutzer.vorname.equals(params.vorname))
		return true
	if(!nutzer.nachname.equals(params.nachname))
		return true
	if(!nutzer.strasse.equals(params.strasse))
		return true
	if(!nutzer.plz.equals(params.plz))
		return true
	if(!nutzer.ort.equals(params.ort))
		return true
	if(!nutzer.anmerkung.equals(params.anmerkung))
		return true
	try
	{
		Long r = new Long(params.rolle)
		if(r != nutzer.rolle)
			return true
	}
	catch(Exception e){}
	try
	{
		Long r = new Long(params.kategorie)
		if(r != nutzer.kategorie)
			return true
	}
	catch(Exception e){}
	try
	{
		Long r = new Long(params.status)
		if(r != nutzer.status)
			return true
	}
	catch(Exception e){}
	return false
}
private void update()
{
	boolean some_changed = false
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	String tmessage = "";
	
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			tmessage += '['+nutzer.key+'] '
			boolean changed = hasUserChanged(params, nutzer)
			if(changed)
			{
				nutzer.vorname = params.vorname
				nutzer.nachname = params.nachname
				nutzer.anzeigename = nutzer.vorname+' '+nutzer.nachname
				nutzer.strasse = params.strasse
				nutzer.plz = params.plz
				nutzer.ort = params.ort
				nutzer.anmerkung = params.anmerkung
				
				nutzer.save()
				some_changed = true
				tmessage += 'Die Adress-Daten wurden überarbeitet. '
			}
			
			//E-Mail
			if(params.email && !params.email.equals(''))
			{
				boolean create_new = false
				try
				{
					def query = new Query(Konstanten.TELEKOMM)
					query.addFilter("gast", Query.FilterOperator.EQUAL, nutzer.key.id)
					query.addFilter("typ", Query.FilterOperator.EQUAL, new Long(0))
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	def entity = preparedQuery.asSingleEntity()
				 	if(entity == null)
				 		create_new = true
			 		else
			 		{
			 			//Es gibt schon eine Mailadresse zu dem Benutzer
			 			//und der hat sich auch verändert
			 			if(!entity.wert.equals(params.email))
			 			{
			 				entity.wert = params.email
			 				entity.save()
			 				some_changed = true
			 				tmessage += 'Die E-Mail Adresse wurde geändert. '
			 			}
			 		}
				}
				catch(Exception e)
				{
					create_new = true
				}
				if(create_new)
				{
					Telekomm t = new Telekomm()
					t.typ = new Long(0)
					t.gast = nutzer.key.id
					t.wert = params.email
					
					Entity e = t as Entity
					e.save()
					some_changed = true
					tmessage += 'Neue E-Mail Adresse hinzugefügt. '
				}
			}
			//Handy
			if(params.handy && !params.handy.equals(''))
			{
				
				boolean create_new = false
				try
				{
					def query = new Query(Konstanten.TELEKOMM)
					query.addFilter("gast", Query.FilterOperator.EQUAL, nutzer.key.id)
					query.addFilter("typ", Query.FilterOperator.EQUAL, new Long(1))
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	def entity = preparedQuery.asSingleEntity()
				 	if(entity == null)
				 		create_new = true
			 		else
			 		{
			 			//Es gibt schon eine Handynummer zu dem Benutzer
			 			//und der hat sich auch verändert
			 			if(!entity.wert.equals(params.handy))
			 			{
			 				entity.wert = params.handy
			 				entity.save()
			 				some_changed = true
			 				tmessage += 'Die Handynummer wurde geändert. '
			 			}
			 			
			 		}
				}
				catch(Exception e)
				{
					create_new = true
				}
				if(create_new)
				{
					Telekomm t = new Telekomm()
					t.typ = new Long(1)
					t.gast = nutzer.key.id
					t.wert = params.handy
					
					Entity e = t as Entity
					e.save()
					some_changed = true
					tmessage += 'Neue Handynummer hinzugefügt. '
				}
				
			}
			//Telefon
			if(params.telefon && !params.telefon.equals(''))
			{
				boolean create_new = false
				try
				{
					def query = new Query(Konstanten.TELEKOMM)
					query.addFilter("gast", Query.FilterOperator.EQUAL, nutzer.key.id)
					query.addFilter("typ", Query.FilterOperator.EQUAL, new Long(2))
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	def entity = preparedQuery.asSingleEntity()
				 	if(entity == null)
				 		create_new = true
			 		else
			 		{
			 			//Es gibt schon eine Handynummer zu dem Benutzer
			 			//und der hat sich auch verändert
			 			if(!entity.wert.equals(params.telefon))
			 			{
			 				entity.wert = params.telefon
			 				entity.save()
			 				some_changed = true
			 				tmessage += 'Die Telefonnummer wurde geändert. '
			 			}
			 		}
				}
				catch(Exception e)
				{
					create_new = true
				}
				if(create_new)
				{
					Telekomm t = new Telekomm()
					t.typ = new Long(2)
					t.gast = nutzer.key.id
					t.wert = params.telefon
					
					Entity e = t as Entity
					e.save()
					some_changed = true
					tmessage += 'Neue Telefonnummer hinzugefügt. '
				}
				
			}
			
		}
		else
		{
			String message = "Es wurde versucht ein Gast zu updaten, der nicht zur eigenen Feier gehört: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gliste.gaeste.update(): Gast gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast zu updaten, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gliste.gaeste.update(): Gast nicht gefunden zum updaten. Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		index()
	}
	if(some_changed)
	{
		createTracer(Konstanten.TRACER_UPDATE , tmessage)
		request.message = 'Daten des Gastes aktualisiert.'
	}
	edit()
}
private void updatekind()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	boolean some_changed = false
	String tmessage = "";	
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			tmessage += '['+nutzer.key+'] '
			//update
			if(params.kkey)
			{
				Key k1 = KeyFactory.stringToKey(params.kkey)
				
				def mykind = datastore.get(k1);
				if(!mykind.name.equals(params.name))
				{
					some_changed = true
					mykind.name = params.name
					tmessage += 'Der Name des Kindes wurde geändert. '
				}
				try
				{
					Long alter = new Long(params.alter)
					if(alter != mykind.alter)
					{
						some_changed = true
						mykind.alter = alter
						tmessage += 'Das Alter des Kindes wurde geändert. '
					}
				}
				catch(Exception e){}
				if(some_changed)
				{
					mykind.save()
					request.message = 'Kind '+mykind.name+' aktualisiert'
					createTracer(Konstanten.TRACER_UPDATE, tmessage)
				}
			}
			//erstellen
			else
			{
				try
				{
					Kind ki = new Kind()
					ki.name = params.name
					ki.gast = nutzer.key.id
					ki.zusage = false
					ki.feier = session.getAttribute(Konstanten.SESSION_USER).feier
					ki.status = new Long(2)
					ki.anmerkungZusage = ''
						
					try
					{
						if(params.alter && !params.alter.equals('') && !params.alter.equals('null'))
							ki.alter = new Long(params.alter)
					}
					catch(Exception e){}
					
					Entity e = ki as Entity
					e.save()
					request.message = 'Neues Kind hinzugefügt'
				}
				catch(Exception e)
				{
					log.warning(e.toString())
				}
				
			}
		}
		else
		{
			String message = "Es wurde versucht ein Kind zu updaten, das nicht zur eigenen Feier gehört. Gast zum Kind: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gliste.gaeste.updatekind(): Gast/Kind gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+myuser)
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast-Kind zu updaten, das es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gliste.updatekind(): Gast/Kind nicht gefunden zum updaten. Benutzer der gesucht hat: "+params+" Benutzer der gesucht hat: "+myuser)
		
	}
	
	edit()	
}
private void updateanhang()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	boolean some_changed = false
	String tmessage = "";
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			tmessage += '['+nutzer.key+'] '
			//update
			if(params.kkey)
			{
				Key k1 = KeyFactory.stringToKey(params.kkey)
				
				def mykind = datastore.get(k1);
				if(!mykind.name.equals(params.name))
				{
					some_changed = true
					mykind.name = params.name
					tmessage += 'Der Name der Begleitung wurde geändert.'
				}
				try
				{
					Long status = new Long(params.status)
					if(mykind.status != status)
					{
						mykind.status = status
						some_changed = true
					}
				}
				catch(Exception e){}
				if(some_changed)
				{
					mykind.save()
					request.message = 'Begleitung '+mykind.name+' aktualisiert'
					createTracer(Konstanten.TRACER_UPDATE, tmessage)
				}
			}
			else
			{
				try
				{
					Anhang ki = new Anhang()
					ki.name = params.name
					ki.gast = nutzer.key.id
					ki.zusage = false
					ki.feier = session.getAttribute(Konstanten.SESSION_USER).feier
					ki.status = new Long(2)
					ki.anmerkungZusage = ''
						
					
					Entity e = ki as Entity
					e.save()
					request.message = 'Neue Begleitung hinzugefügt: '+params.name
				}
				catch(Exception e)
				{
					log.warning(e.toString())
				}
				
			}
		}
		else
		{
			String message = "Es wurde versucht eine Begleitung zu updaten, die nicht zur eigenen Feier gehört. Gast zur Begleitung: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gliste.gaeste.updateanhang(): Gast gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast-Anhang zu updaten, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gliste.gaeste.updateanhang(): Gast nicht gefunden zum updaten. Benutzer der gesucht hat: "+params+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
	}
	
	edit()	
}
private void createTracer(String message)
{
	createTracer(Konstanten.TRACER_FORGOT, message);
}
private void createTracer(String type, String message) {
	try
	{
		def myuser = session.getAttribute(Konstanten.SESSION_USER);

		Tracer t = new Tracer()
	    t.ipadresse = request.getRemoteAddr()
	    t.user = myuser.key
	    t.type = type
	    t.nachricht = message
	    t.datum = Datehelper.getNow()
	    Entity e2 = t as Entity
		e2.save()
	}
	catch(Exception e)
	{
		
	}
}
private int getOrder()
{
	private int myorder = -1;
	if(params.order && !params.order.equals('') && !params.order.equalsIgnoreCase('null'))
	{
		try
		{
			String wert = params.order
			int order = (new Integer(wert)).intValue()
			myorder = order * -1
		}
		catch(Exception e)
		{
			e.printStackTrace()
		}
	}
	
	return myorder;
}